package com.authorization.project.authorization.service.impl;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

import com.authorization.common.utils.DateUtils;
import com.authorization.common.utils.SecurityUtils;
import com.authorization.common.utils.StringUtils;
import com.authorization.framework.web.domain.TreeSelect;
import com.authorization.project.authorization.service.IAuthorizationMoudleMappingService;
import com.authorization.project.authorization.service.IMicroserviceService;
import com.authorization.project.authorization.service.IMoudleMicroserviceMappingService;
import com.authorization.project.system.domain.SysMenu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.authorization.project.authorization.mapper.ModuleMapper;
import com.authorization.project.authorization.domain.Module;
import com.authorization.project.authorization.service.IModuleService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 模块Service业务层处理
 * 
 * @author 李晓雷
 * @date 2020-04-22
 */
@Service
public class ModuleServiceImpl implements IModuleService 
{
    @Autowired
    private ModuleMapper moduleMapper;

    @Autowired
    private IMoudleMicroserviceMappingService moudleMicroserviceMappingService;

    @Autowired
    private IAuthorizationMoudleMappingService iAuthorizationMoudleMappingService;

    /**
     * 查询模块
     * 
     * @param id 模块ID
     * @return 模块
     */
    @Override
    public Module selectModuleById(Long id)
    {
        Module module = moduleMapper.selectModuleById(id);
        //查询模块微服务中间表
        module.setServiceIdsList(moudleMicroserviceMappingService.selectMoudleMicroserviceIdsByModuleId(id));
        return module;
    }

    /**
     * 查询模块列表
     * 
     * @param module 模块
     * @return 模块
     */
    @Override
    public List<Module> selectModuleList(Module module)
    {
        return moduleMapper.selectModuleList(module);
    }

    /**
     * 新增模块
     *`
     * @param module 模块
     * @return 结果
     */
    public int insert(Module module)
    {
        module.setCreateBy(SecurityUtils.getUsername());
        module.setCreateTime(DateUtils.getNowDate());
        return moduleMapper.insertModule(module);
    }

    /**
     * 新增模块
     * 
     * @param module 模块
     * @return 结果
     */
    @Override
    @Transactional
    public int insertModule(Module module)
    {
        //1添加模块
        int rest =this.insert(module);

        //2添加模块微服务中间表
        if(module.getServiceIdsList() !=null && module.getServiceIdsList().size() >0){
            moudleMicroserviceMappingService.bashInsertMicroservice(module.getId(), module.getServiceIdsList());
        }
        return rest;
    }

    /**
     * 修改模块
     *
     * @param module 模块
     * @return 结果
     */
    @Override
    @Transactional
    public int updateModule(Module module)
    {
        if(module.getServiceIdsList() !=null && module.getServiceIdsList().size() >0){
            //1 删除 模块微服务中间表数据
            moudleMicroserviceMappingService.deleteMoudleMicroserviceMappingByModuleId(module.getId());

            //2 添加 模块微服务中间表数据
            moudleMicroserviceMappingService.bashInsertMicroservice(module.getId(), module.getServiceIdsList());
        }

        int rest =this.update(module);
        return rest;
    }

    /**
     * 修改模块
     *
     * @param module 模块
     * @return 结果
     */
    public int update(Module module)
    {
        module.setUpdateBy(SecurityUtils.getUsername());
        module.setUpdateTime(DateUtils.getNowDate());
        return moduleMapper.updateModule(module);
    }

    /**
     * 批量删除模块
     * 
     * @param ids 需要删除的模块ID
     * @return 结果
     */
    @Override
    public int deleteModuleByIds(Long[] ids)
    {
        //1 删除 模块微服务中间表数据
        for (Long id : ids) {
            moudleMicroserviceMappingService.deleteMoudleMicroserviceMappingByModuleId(id);
        }
        //2 删除模块
        return moduleMapper.deleteModuleByIds(ids);
    }

    /**
     * 删除模块信息
     * 
     * @param id 模块ID
     * @return 结果
     */
    @Override
    public int deleteModuleById(Long id)
    {
        return moduleMapper.deleteModuleById(id);
    }

    /**
     * 查询产品列表集合
     * @param productId
     * @return
     */
    @Override
    public List<Module> parentList(Long productId) {
        return moduleMapper.parentList(productId);
    }

    /**
     * 构建前端所需要下拉树结构
     * @param modules
     * @return
     */
    @Override
    public List<TreeSelect> buildModulesTreeSelect(List<Module> modules) {
        List<Module> moduleTrees = buildModulesTree(modules);
        return moduleTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
    }

    /**
     * 根据产品ID查询所有套餐-模块
     * @param productId
     * @return
     */
    @Override
    public List<Module> selectModule(Long productId) {
        //1列表-
        List<Module> firstModuleList = this.selectFirstModuleListByProductId(productId);

        //2查询列表和列表下所有模块
        firstModuleList.stream().forEach(module -> {
            List<Module> nodeList = selectNodeModuleListByParentId(module.getId());
            module.setModuleList(nodeList);
        });
        return firstModuleList;
    }

    /**
     * 根据产品的ID查询基本模块ID集合
     * @param productId
     * @return
     */
    @Override
    public List<Long> selectBaseModuleIdsByProductId(Long productId) {
        return moduleMapper.selectBaseModuleIdsByProductId(productId);
    }

    /**
     * 根据用户编号查询模块英文名称集合
     * @param userid
     * @return
     */
    @Override
    public List<String> selectEnglishListByUserId(String userid) {
        return moduleMapper.selectEnglishListByUserId(userid);
    }

    /**
     * 根据产品ID获取所有一级列表
     * @param productId
     * @return
     */
    private List<Module> selectFirstModuleListByProductId(Long productId) {
        return  moduleMapper.selectFirstModuleListByProductId(productId);
    }

    /**
     * 查询一级列表下所有的子模块
     * @param parentId
     * @return
     */
    private List<Module> selectNodeModuleListByParentId(Long parentId) {
        return moduleMapper.selectNodeModuleListByParentId(parentId);
    }

    /**
     * 赋值选中模块
     * @param nodeList
     * @param finalCheckedModuleIdList
     */
    private void setMoudleChecked(List<Module> nodeList, List<Long> finalCheckedModuleIdList) {
        if(finalCheckedModuleIdList!=null && finalCheckedModuleIdList.size() > 0){
            nodeList.stream().forEach(node ->{
                if(finalCheckedModuleIdList.contains(node.getId()) ){
                    node.setChecked("1");
                }
            });
        }
    }

    /**
     * 根据一级列表和套餐ID查询下级模块
     * @param packageId
     * @param parentId
     * @return
     */
    private List<Module> selectNodeModuleListByPackageIdAndParentId(Long packageId, Long parentId) {
        return moduleMapper.selectNodeModuleListByPackageIdAndParentId(packageId, parentId);
    }

    /**
     * 列表- 根据套餐ID
     * @param packageId
     * @return
     */
    private List<Module> selectFirstModuleListByPackageId(Long packageId) {
        return moduleMapper.selectFirstModuleListByPackageId(packageId);
    }


    /**
     * 构建前端所需要树结构
     *
     * @param modules 列表
     * @return 树结构列表
     */
    private List<Module> buildModulesTree(List<Module> modules) {
        List<Module> returnList = new ArrayList<Module>();
        for (Iterator<Module> iterator = modules.iterator(); iterator.hasNext();)
        {
            Module t = (Module) iterator.next();
            // 根据传入的某个父节点ID,遍历该父节点的下一级子节点
            if (t.getParentId() == null)
            {
                recursionFn(modules, t);
                returnList.add(t);
            }
        }
        if (returnList.isEmpty())
        {
            returnList = modules;
        }
        return returnList;

    }


    /**
     * 查询下一级列表
     *
     * @param list
     * @param t
     */
    private void recursionFn(List<Module> list, Module t)
    {
        // 得到下一级子节点列表
        List<Module> childList = getChildList(list, t);
        t.setChildren(childList);
    }

    /**
     * 得到下一级子节点列表
     */
    private List<Module> getChildList(List<Module> list, Module t)
    {
        List<Module> tlist = new ArrayList<Module>();
        Iterator<Module> it = list.iterator();
        while (it.hasNext())
        {
            Module n = (Module) it.next();
            if (n.getParentId()!=null &&(n.getParentId().longValue() == t.getId().longValue()))
            {
                tlist.add(n);
            }
        }
        return tlist;
    }

}
